#include <iostream>
#include <fcntl.h>      // 定义了 open 函数和各种标志（如 O_RDONLY, O_WRONLY 等）
#include <sys/types.h>  // 定义了一些系统数据类型
#include <sys/stat.h>   // 定义了文件模式的常量（如 S_IRUSR, S_IWUSR 等）
#include <unistd.h>
using namespace std;

class MyFileSystem
{
public:
    MyFileSystem() : m_fd(-1) {}

    MyFileSystem(string& filename,int flags,int mode) 
    {
        myOpen(filename, flags, mode);
    }
    MyFileSystem(const char*filename,int flags,int mode)
    {
        myOpen(filename, flags, mode);
    }

    ~MyFileSystem()
    {
        if (m_fd != -1)
        {
            myClose();
        }
    }

public:

    int myOpen(string& filename,int flags,int mode){
        return myOpen(filename.c_str(), flags, mode);
    }
    int myOpen(const char*filename,int flags,int mode) {
        if (m_fd != -1) {
            myClose();
        }
        m_fd = open(filename, flags, mode);
        if (m_fd == -1) {
            throw std::runtime_error("Failed to open file");
        }
        m_filename = filename;
        return m_fd;
    }

    int myClose()
    {
        if (m_fd != -1) 
        {
            int result = close(m_fd);
            m_fd = -1;
            m_filename.clear();
            return result;
        }
        return 0;
    }

    ssize_t myWrite(const void *buf, size_t count)
    {
        if (m_fd == -1) 
        {
            return -1;  // 或者抛出异常，取决于你的错误处理策略
        }
        return write(m_fd, buf, count);
    }

    ssize_t myRead(void *buf, size_t count)
    {
        if (m_fd == -1) 
        {
            return -1;  // 或者抛出异常，取决于你off_t lseek(int fd, off_t offset, int whence);的错误处理策略
        }
        return read(m_fd, buf, count);
    }

    off_t myLseek(off_t offset, int whence)
    {
        if (m_fd == -1) 
        {
            return -1;  // 或者抛出异常，取决于你的错误处理策略
        }
        return lseek(m_fd, offset, whence);
    }

    int myStat(const char *path,struct stat *buf)
    {
        if (m_fd == -1) 
        {
            return -1;  // 或者抛出异常，取决于你的错误处理策略
        }
        return stat(path,buf);
    }

    int myAccess(const char *pathname, int mode)
    {
        if (m_fd == -1) 
        {
            return -1;  // 或者抛出异常，取决于你的错误处理策略
        }
        return access(pathname,mode);
    }

    int myChmod(const char *pathname, mode_t mode)
    {
        if (m_fd == -1) 
        {
            return -1;  // 或者抛出异常，取决于你的错误处理策略
        }
        return chmod(pathname,mode);
    }

    int myChown(const char *pathname, uid_t owner, gid_t group)
    {
        if (m_fd == -1) 
        {
            return -1;  // 或者抛出异常，取决于你的错误处理策略
        }
        return chown(pathname,owner,group);
    }

    int myTruncate(const char *path, off_t length)
    {
        if (m_fd == -1) 
        {
            return -1;  // 或者抛出异常，取决于你的错误处理策略
        }
        return truncate(path,length);
    }

    
private:
    string m_filename;
    int m_fd;
};


int main()
{
    ofstream ofs();
    return 0;
}